package kn.cstf2.global.Utils;

import kn.cstf2.global.Utils.CstF2Exception;
import kn.cstf2.global.Utils.ConectaProperties;
import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.logging.Level;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import kn.cstf2.global.Utils.FtpOperations;

public class ConexionFtp {

    FtpOperations ftpO = new FtpOperations();
    private ConectaProperties con = new ConectaProperties();
    FTPClient ftpClient = new FTPClient();

    private String host = new String();
    private Integer port;
    private String user = new String();
    private String password = new String();
    private String done = new String();
    private String err = new String();
    private String nombrePropertie = new String();
    private ArrayList<File> arrayFiles = new ArrayList<File>();
    private String directorioServidor = new String();
    private ArrayList<String> nombresArchivos = new ArrayList<String>();

    public String getNombrePropertie() {
        return nombrePropertie;
    }

    public void setNombrePropertie(String nombrePropertie) {
        this.nombrePropertie = nombrePropertie;
    }

    public ArrayList<String> getNombresArchivos() {
        return nombresArchivos;
    }

    public void setNombresArchivos(ArrayList<String> nombresArchivos) {
        this.nombresArchivos = nombresArchivos;
    }

    public String getDirectorioServidor() {
        return directorioServidor;
    }

    public void setDirectorioServidor(String directorioServidor) {
        this.directorioServidor = directorioServidor;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public ConexionFtp() {
        //conectaProperties();
        ftpO.obtenerParametrosConexion();
        host = ftpO.getHost();
        port = ftpO.getPort();
        user = ftpO.getUsuario();
        password = ftpO.getPassword();
        done = ftpO.getFolder();
        err = ftpO.getFolderErr();
        nombrePropertie = ftpO.getNombrePro();
    }

    public ConexionFtp(String carpeta) {
        //conectaProperties();
        ftpO.obtenerParametrosConexion();
        host = ftpO.getHost();
        port = ftpO.getPort();
        user = ftpO.getUsuario();
        password = ftpO.getPassword();
        done = ftpO.getFolder();
        err = ftpO.getFolderErr();
        nombrePropertie = ftpO.getNombrePro();
        directorioServidor = ftpO.getFolder() + carpeta + "/";
    }

    private void loggea() {
        try {
            //ftpClient.connect(host);
            ftpClient.connect(host, port);
            boolean logged = ftpClient.login(user, password);
            if (!logged) {
                throw new CstF2Exception("Fallo el loggeo");
            }
            ftpClient.changeWorkingDirectory(directorioServidor);
        } catch (Exception e) {
            try {
                ftpClient.disconnect();
            } catch (IOException ex) {
                java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
            }


        }
    }

    public Boolean guarda(String nombre, String folder, InputStream fis) {
        loggea();
        InputStream in = null;
        try {
            in = fis;
            if (nombre.contains(".txt")) {
                ftpClient.setFileType(FTPClient.ASCII_FILE_TYPE);
            } else {
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            }
            ftpClient.changeWorkingDirectory(done + folder);
            ftpClient.storeFile(nombre, in);
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        desconecta();
        return true;
    }

    public void guardaDone(String nombre, FileInputStream fis) {
        loggea();
        InputStream in = null;
        try {
            in = fis;
            ftpClient.changeWorkingDirectory(done);
            ftpClient.storeFile(nombre, in);
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        desconecta();
    }

    public void guardaErr(String nombre, FileInputStream fis) {
        loggea();
        InputStream in = null;
        try {
            in = fis;
            ftpClient.changeWorkingDirectory(err);
            ftpClient.storeFile(nombre, in);
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        desconecta();
    }

    public void borra(String nombre, String folder) {
        loggea();
        try {
            ftpClient.changeWorkingDirectory(done + folder);
            ftpClient.deleteFile(nombre);
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconecta();
    }

    public ArrayList enlistaDir(int knkey) {
        loggea();
        try {
            //ftpClient.changeWorkingDirectory(directorioServidor);
            FTPFile[] files = ftpClient.listFiles();
            for (FTPFile file : files) {
                if (file.getName().contains("_" + knkey)) {
                    nombresArchivos.add(file.getName());
                }
            }
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconecta();
        return nombresArchivos;
    }

    public InputStream obtenInfo(String nombre) throws IOException {
        loggea();
        if (nombre.contains(".txt")) {
            ftpClient.setFileType(FTPClient.ASCII_FILE_TYPE);
        } else {
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
        }
        InputStream fis = ftpClient.retrieveFileStream(nombre);
        return fis;
    }

    private void desconecta() {
        try {
            ftpClient.disconnect();
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ConexionFtp.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void llenaNombres() {
    }

    public void conectaProperties() {
        Map<String, String> prop = con.leerProperties(nombrePropertie);

        int i = 0;
        for (Iterator it = prop.keySet().iterator(); it.hasNext();) {
            switch (i) {
                case 0:
                    directorioServidor = prop.get((String) it.next());
                    break;
                case 1:
                    done = prop.get((String) it.next());
                    break;
                case 2:
                    err = prop.get((String) it.next());
                    break;
                case 3:
                    password = prop.get((String) it.next());
                    break;
                case 4:
                    user = prop.get((String) it.next());
                    break;
                case 5:
                    host = prop.get((String) it.next());
                    break;
            }
            i++;
        }
    }

    public void agregaArchivo(String nombre) {

        File file = new File(nombre);
        arrayFiles.add(file);
    }

    public InputStream downloadFile(String nombre) throws IOException {
        InputStream in = null;
        String fileName = "YOUR FILE PATH";

        in = ftpClient.retrieveFileStream(nombre);
        if (in == null) {
            System.out.println("---------------------Esta vacio-----------------\n");
        }

        return in;


    }

    public static void main(String[] args) throws IOException {
        ConexionFtp c = new ConexionFtp();
        c.agregaArchivo(c.getNombrePropertie());
        // c.conectaProperties();
        //c.enlistaDir();
        for (String nombre : c.getNombresArchivos()) {
            c.obtenInfo(nombre);
            //c.downloadFile(nombre);


        }

    }
}
